/**
 * 测试数据生成器
 * 用于创建测试数据以便于开发和测试
 */
import { taskService } from './task-service'
import type { Task } from './task-service'
import { dbService, TABLES } from './database'
import { generateUUID } from '../utils/id'

/**
 * 测试数据生成器类
 */
class DataGenerator {
  /**
   * 生成随机测试任务
   * @param count 需要生成的任务数量
   * @returns 是否成功
   */
  async generateTasks(count: number = 10): Promise<boolean> {
    try {
      // 确保数据库已初始化
      if (!dbService.isInitialized()) {
        console.warn('数据库尚未初始化，操作可能失败');
        // 可以考虑等待一段时间或提示用户
        return false;
      }
      
      const categories = ['工作', '个人', '学习', '购物', '家庭', '娱乐', '其他']
      const priorities = ['high', 'medium', 'low'] as const
      const titles = [
        '完成项目方案',
        '准备会议材料',
        '购买生日礼物',
        '阅读新书',
        '健身锻炼',
        '整理房间',
        '修复电脑问题',
        '学习新技术',
        '拜访朋友',
        '写周报',
        '复习考试',
        '预约医生',
        '支付账单',
        '购买日用品',
        '整理照片',
        '写博客文章',
        '规划旅行',
        '更新简历',
        '收集资料',
        '联系客户'
      ]
      
      // 生成今天和未来7天的日期
      const dates = []
      for (let i = 0; i < 7; i++) {
        const date = new Date()
        date.setDate(date.getDate() + i)
        dates.push(date.toISOString().split('T')[0])
      }
      
      // 批量处理任务生成，减小每批的数量，提高稳定性
      const batchSize = 3; 
      const batches = Math.ceil(count / batchSize);
      let totalSuccess = true;
      
      // 显示进度条
      uni.showLoading({
        title: '生成数据中(0%)',
        mask: true
      });
      
      for (let batch = 0; batch < batches; batch++) {
        const batchTasks = [];
        const batchStart = batch * batchSize;
        const batchEnd = Math.min((batch + 1) * batchSize, count);
        
        // 为当前批次生成任务
        for (let i = batchStart; i < batchEnd; i++) {
          const randomTitle = titles[Math.floor(Math.random() * titles.length)]
          const randomCategoryId = categories[Math.floor(Math.random() * categories.length)]
          const randomPriority = priorities[Math.floor(Math.random() * priorities.length)]
          const randomDate = dates[Math.floor(Math.random() * dates.length)]
          const randomCompleted = Math.random() > 0.7 // 30%概率为已完成
          const randomReminder = Math.random() > 0.3 // 70%概率开启提醒
          
          // 随机生成时间段
          const startHour = Math.floor(Math.random() * 12) + 8 // 8点到19点之间
          const endHour = startHour + Math.floor(Math.random() * 3) + 1 // 开始时间后1-3小时
          const timeRange = `${startHour}:00 - ${endHour}:00`
          
          // 生成随机描述
          const descriptions = [
            '需要尽快完成这项任务',
            '这是一个重要的任务，需要认真对待',
            '记得提前准备相关材料',
            '与团队成员协作完成',
            '这个任务可能需要额外时间',
            '',
            '参考之前的工作内容',
            '需要在截止日期前完成'
          ]
          const randomDescription = descriptions[Math.floor(Math.random() * descriptions.length)]
          
          // 创建任务对象
          const task: Task = {
            id: generateUUID(),
            title: `${randomTitle} ${i + 1}`,
            categoryId: randomCategoryId,
            priority: randomPriority,
            date: randomDate,
            timeRange: timeRange,
            completed: randomCompleted,
            reminder: randomReminder,
            description: randomDescription,
            attachments: [],
            createdAt: new Date().toISOString(),
            updatedAt: new Date().toISOString()
          }
          
          batchTasks.push(task);
        }
        
        try {
          // 保存当前批次的任务
          const savePromises = batchTasks.map(task => {
            const dbTask = {
              id: task.id,
              title: task.title,
              categoryId: task.categoryId  || null,
              priority: task.priority,
              date: task.date || null,
              timeRange: task.timeRange || null,
              completed: task.completed ? 1 : 0,
              reminder: task.reminder ? 1 : 0,
              description: task.description || null,
              attachments: null,
              createdAt: task.createdAt,
              updatedAt: task.updatedAt,
            };
            return dbService.insert(TABLES.TASKS, dbTask);
          });
          
          const results = await Promise.all(savePromises);
          
          // 检查是否所有任务都保存成功
          if (results.some(result => !result)) {
            console.warn(`批次 ${batch + 1}/${batches} 中有任务保存失败`);
            totalSuccess = false;
          }
        } catch (batchError) {
          console.error(`批次 ${batch + 1}/${batches} 保存失败:`, batchError);
          totalSuccess = false;
          
          // 尝试更多的间隔时间
          await new Promise(resolve => setTimeout(resolve, 500));
        }
        
        // 给UI线程更多喘息的时间，防止卡顿
        await new Promise(resolve => setTimeout(resolve, 200));
        
        // 更新进度
        const progress = Math.floor((batchEnd / count) * 100);
        uni.showLoading({
          title: `生成数据中(${progress}%)`,
          mask: true
        });
        
        // 报告进度
        console.log(`已生成 ${batchEnd}/${count} 条测试任务数据`);
      }
      
      // 隐藏加载提示
      uni.hideLoading();
      
      // 如果有失败，但总体成功了大部分，仍然返回成功
      return totalSuccess;
    } catch (error) {
      // 隐藏加载提示
      uni.hideLoading();
      console.error('生成测试数据失败:', error)
      return false
    }
  }

  /**
   * 生成随机财务记录测试数据
   * @param count 需要生成的记录数量
   * @returns 是否成功
   */
  async generateFinancialRecords(count: number = 10): Promise<boolean> {
    try {
      // 确保数据库已初始化
      if (!dbService.isInitialized()) {
    console.warn('数据库尚未初始化，操作可能失败');
    // 可以考虑等待一段时间或提示用户
    return;
  }
      
      const types = ['收入', '支出']
      const categories = {
        '收入': ['工资', '奖金', '兼职', '投资', '其他收入'],
        '支出': ['餐饮', '交通', '购物', '娱乐', '医疗', '教育', '住房', '其他支出']
      }
      const accounts = ['现金', '支付宝', '微信', '信用卡', '储蓄卡']
      const notes = [
        '月度例行花销',
        '临时购买',
        '日常消费',
        '必要开支',
        '紧急支出',
        '计划内花销',
        '',
        '节省了一些'
      ]
      
      // 生成过去30天的日期
      const dates = []
      for (let i = 0; i < 30; i++) {
        const date = new Date()
        date.setDate(date.getDate() - i)
        dates.push(date.toISOString().split('T')[0])
      }
      
      // 生成随机财务记录
      for (let i = 0; i < count; i++) {
        const type = types[Math.floor(Math.random() * types.length)]
        const category = categories[type][Math.floor(Math.random() * categories[type].length)]
        const account = accounts[Math.floor(Math.random() * accounts.length)]
        const date = dates[Math.floor(Math.random() * dates.length)]
        const note = notes[Math.floor(Math.random() * notes.length)]
        
        // 随机金额(收入100-10000，支出10-1000)
        let amount
        if (type === '收入') {
          amount = Math.floor(Math.random() * 9900) + 100
        } else {
          amount = Math.floor(Math.random() * 990) + 10
        }
        
        // 保存财务记录
        const record = {
          id: generateUUID(),
          type,
          amount,
          category,
          date,
          account,
          note,
          photos: '',
          createdAt: new Date().toISOString(),
          updatedAt: new Date().toISOString()
        }
        
        await dbService.insert(TABLES.FINANCE_RECORDS, record)
      }
      
      return true
    } catch (error) {
      console.error('生成财务记录测试数据失败:', error)
      return false
    }
  }

  /**
   * 生成随机番茄钟记录测试数据
   * @param count 需要生成的记录数量
   * @returns 是否成功
   */
  async generatePomodoroRecords(count: number = 10): Promise<boolean> {
    try {
      // 确保数据库已初始化
      if (!dbService.isInitialized()) {
    console.warn('数据库尚未初始化，操作可能失败');
    // 可以考虑等待一段时间或提示用户
    return;
  }
      
      // 获取所有任务ID用于关联
      const tasks = await taskService.getTodayTasks()
      const taskIds = tasks.map(task => task.id)
      
      const types = ['work', 'break', 'long-break']
      const interruptionReasons = [
        '接到电话',
        '同事打断',
        '有紧急事情',
        '需要休息',
        '',
        '家人需要帮助',
        '突然有会议'
      ]
      
      // 生成过去14天的日期时间
      const startTimes = []
      for (let i = 0; i < 14; i++) {
        const day = new Date()
        day.setDate(day.getDate() - i)
        
        // 每天生成3个随机时间点
        for (let j = 0; j < 3; j++) {
          const hour = 9 + j * 3 // 9点、12点、15点为基准
          const minute = Math.floor(Math.random() * 60)
          day.setHours(hour, minute, 0, 0)
          startTimes.push(new Date(day))
        }
      }
      
      // 生成随机番茄钟记录
      for (let i = 0; i < count; i++) {
        const startTime = startTimes[Math.floor(Math.random() * startTimes.length)]
        const type = types[Math.floor(Math.random() * types.length)]
        
        // 根据类型设置时长
        let duration
        if (type === 'work') {
          duration = 25 * 60 // 25分钟(秒)
        } else if (type === 'break') {
          duration = 5 * 60 // 5分钟(秒)
        } else {
          duration = 15 * 60 // 15分钟(秒)
        }
        
        // 计算结束时间
        const endTime = new Date(startTime.getTime() + duration * 1000)
        
        // 随机是否完成或被打断
        const completed = Math.random() > 0.2 // 80%概率完成
        const interrupted = !completed && Math.random() > 0.5 // 如果未完成，50%概率是被打断的
        
        // 关联任务(只有工作类型才关联任务)
        let taskId = null
        if (type === 'work' && taskIds.length > 0) {
          taskId = taskIds[Math.floor(Math.random() * taskIds.length)]
        }
        
        // 如果被打断，随机选择原因
        let interruptionReason = null
        if (interrupted) {
          interruptionReason = interruptionReasons[Math.floor(Math.random() * interruptionReasons.length)]
        }
        
        // 保存番茄钟记录
        const record = {
          id: generateUUID(),
          taskId,
          startTime: startTime.toISOString(),
          endTime: completed ? endTime.toISOString() : null,
          duration,
          type,
          completed: completed ? 1 : 0,
          interrupted: interrupted ? 1 : 0,
          interruptionReason,
          createdAt: new Date().toISOString()
        }
        
        await dbService.insert(TABLES.POMODORO_RECORDS, record)
      }
      
      return true
    } catch (error) {
      console.error('生成番茄钟记录测试数据失败:', error)
      return false
    }
  }

  /**
   * 生成随机笔记测试数据
   * @param count 需要生成的笔记数量
   * @returns 是否成功
   */
  async generateNotes(count: number = 5): Promise<boolean> {
    try {
      // 确保数据库已初始化
      if (!dbService.isInitialized()) {
    console.warn('数据库尚未初始化，操作可能失败');
    // 可以考虑等待一段时间或提示用户
    return;
  }
      
      const titles = [
        '项目笔记',
        '学习笔记',
        '会议记录',
        '想法收集',
        '书籍摘抄',
        '旅行计划',
        '健康记录',
        '购物清单',
        '目标规划',
        '每日反思'
      ]
      
      const contents = [
        '这是一个关于项目的笔记，记录了一些重要的想法和计划。\n\n- 第一项：完成需求分析\n- 第二项：设计用户界面\n- 第三项：实现核心功能',
        '今天学习了一些新的知识点：\n\n1. JavaScript的闭包概念\n2. CSS Grid布局技巧\n3. React Hooks的使用方法',
        '会议要点：\n\n- 项目进度：已完成70%\n- 遇到的问题：API接口不稳定\n- 解决方案：增加错误重试机制\n- 下一步计划：完成剩余功能并进行测试',
        '最近的一些想法：\n\n也许我们可以尝试一种新的方法来解决这个问题。将用户体验放在首位，简化操作流程，减少用户的学习成本。',
        '《原子习惯》读书笔记：\n\n习惯形成的四个步骤：提示、渴望、反应和奖励。要改变一个习惯，可以从这四个方面入手。',
        '计划参加的旅行：\n\n- 目的地：杭州\n- 时间：10月1日-7日\n- 必去景点：西湖、灵隐寺、宋城\n- 预算：5000元',
        '健康目标：\n\n- 每天运动30分钟\n- 减少糖分摄入\n- 晚上11点前睡觉\n- 每周至少吃三次蔬菜沙拉',
        '周末需要购买的物品：\n\n1. 洗发水\n2. 牙膏\n3. 纸巾\n4. 鲜奶\n5. 面包',
        '本月目标：\n\n- 完成项目第一阶段\n- 阅读两本书\n- 学习一门新技能\n- 存钱3000元',
        '今天遇到了一些挑战，但也有一些收获。需要改进的地方是时间管理，明天会更加合理地安排任务优先级。'
      ]
      
      const colors = ['#F9F9A1', '#D4F4F9', '#FDD6E3', '#C1EADD', '#E2CBF7', '#F9D9CA', '#FFFFFF']
      const tagOptions = ['工作', '学习', '生活', '创意', '计划', '日记', '备忘', '重要']
      
      // 生成随机笔记
      for (let i = 0; i < count; i++) {
        const title = titles[Math.floor(Math.random() * titles.length)]
        const content = contents[Math.floor(Math.random() * contents.length)]
        const color = colors[Math.floor(Math.random() * colors.length)]
        
        // 随机生成1-3个标签
        const tagCount = Math.floor(Math.random() * 3) + 1
        const tags = []
        for (let j = 0; j < tagCount; j++) {
          const tag = tagOptions[Math.floor(Math.random() * tagOptions.length)]
          if (!tags.includes(tag)) {
            tags.push(tag)
          }
        }
        
        // 生成创建和更新时间(过去30天内)
        const createdAt = new Date()
        createdAt.setDate(createdAt.getDate() - Math.floor(Math.random() * 30))
        const updatedAt = new Date(createdAt)
        if (Math.random() > 0.5) { // 50%概率有更新
          updatedAt.setHours(updatedAt.getHours() + Math.floor(Math.random() * 48) + 1) // 1-48小时后更新
        }
        
        // 保存笔记
        const note = {
          id: generateUUID(),
          title: `${title} ${i + 1}`,
          content,
          color,
          tags: JSON.stringify(tags),
          createdAt: createdAt.toISOString(),
          updatedAt: updatedAt.toISOString()
        }
        
        await dbService.insert(TABLES.NOTES, note)
      }
      
      return true
    } catch (error) {
      console.error('生成笔记测试数据失败:', error)
      return false
    }
  }

  /**
   * 生成所有测试数据
   * @returns 是否成功
   */
  async generateAllTestData(): Promise<boolean> {
    try {
      // #ifdef APP-PLUS || H5
      // 生成任务数据
      await this.generateTasks(15)
      // 生成财务记录
      await this.generateFinancialRecords(20)
      // 生成番茄钟记录
      await this.generatePomodoroRecords(30)
      // 生成笔记
      await this.generateNotes(10)
      // #endif
      
      return true;
    } catch (error) {
      console.error('生成所有测试数据失败:', error)
      return false
    }
  }

  /**
   * 清空所有测试数据
   * @returns 是否成功
   */
  async clearAllTestData(): Promise<boolean> {
    try {
      // #ifdef APP-PLUS || H5
      // 确保数据库已初始化
      if (!dbService.isInitialized()) {
    console.warn('数据库尚未初始化，操作可能失败');
    // 可以考虑等待一段时间或提示用户
    return;
  }
      
      // 清空所有表
      await dbService.executeSql(`DELETE FROM ${TABLES.TASKS}`)
      await dbService.executeSql(`DELETE FROM ${TABLES.FINANCE_RECORDS}`)
      await dbService.executeSql(`DELETE FROM ${TABLES.POMODORO_RECORDS}`)
      await dbService.executeSql(`DELETE FROM ${TABLES.NOTES}`)
      // #endif
      
      return true
    } catch (error) {
      console.error('清空测试数据失败:', error)
      return false
    }
  }
}

// 导出数据生成器单例
export const dataGenerator = new DataGenerator() 